import { get, post, getWithPagination, postWithPagination } from './commonApi.js'

/**
 * 分页查询工具类
 */
export class PaginationQuery {
  /**
   * 构造函数
   * @param {string} url - API接口地址
   * @param {Object} defaultOptions - 默认分页选项
   */
  constructor(url, defaultOptions = {}) {
    this.url = url
    this.defaultOptions = {
      currentPage: 1,
      size: 10,
      ...defaultOptions
    }
  }

  /**
   * 执行分页查询
   * @param {Object} options - 查询选项
   * @param {number} options.currentPage - 当前页码
   * @param {number} options.size - 每页数量
   * @param {Object} options.otherParams - 其他查询参数
   * @param {string} options.method - 请求方法，'GET' 或 'POST'，默认为 'GET'
   * @returns {Promise} 分页查询结果
   */
  async query(options = {}) {
    const mergedOptions = {
      ...this.defaultOptions,
      ...options
    }

    const { method = 'GET' } = mergedOptions

    if (method.toUpperCase() === 'POST') {
      return await postWithPagination(this.url, mergedOptions)
    } else {
      return await getWithPagination(this.url, mergedOptions)
    }
  }

  /**
   * 获取第一页数据
   * @param {Object} otherParams - 其他查询参数
   * @returns {Promise} 分页查询结果
   */
  async getFirstPage(otherParams = {}) {
    return await this.query({
      currentPage: 1,
      otherParams
    })
  }

  /**
   * 获取指定页数据
   * @param {number} currentPage - 页码
   * @param {Object} otherParams - 其他查询参数
   * @returns {Promise} 分页查询结果
   */
  async getPage(currentPage, otherParams = {}) {
    return await this.query({
      currentPage,
      otherParams
    })
  }

  /**
   * 搜索查询
   * @param {string} keyword - 搜索关键词
   * @param {Object} otherParams - 其他查询参数
   * @returns {Promise} 分页查询结果
   */
  async search(keyword, otherParams = {}) {
    return await this.query({
      currentPage: 1,
      otherParams: {
        keyword,
        ...otherParams
      }
    })
  }
}

/**
 * 分页查询工厂函数
 * @param {string} url - API接口地址
 * @param {Object} defaultOptions - 默认分页选项
 * @returns {PaginationQuery} 分页查询实例
 */
export const createPaginationQuery = (url, defaultOptions = {}) => {
  return new PaginationQuery(url, defaultOptions)
}

/**
 * 分页查询结果类型定义
 * @typedef {Object} PaginationResult
 * @property {Array} list - 数据列表
 * @property {Object} pagination - 分页信息
 * @property {number} pagination.currentPage - 当前页码
 * @property {number} pagination.size - 每页数量
 * @property {number} pagination.total - 总数据量
 * @property {number} pagination.pages - 总页数
 */

/**
 * 分页查询选项类型定义
 * @typedef {Object} PaginationOptions
 * @property {number} currentPage - 当前页码，默认为1
 * @property {number} size - 每页数量，默认为10
 * @property {Object} otherParams - 其他查询参数
 * @property {string} method - 请求方法，'GET' 或 'POST'
 */

/**
 * 快速分页查询函数
 * @param {string} url - API接口地址
 * @param {PaginationOptions} options - 分页选项
 * @returns {Promise<PaginationResult>} 分页查询结果
 */
export const quickPaginationQuery = async (url, options = {}) => {
  const { method = 'GET', ...queryOptions } = options
  
  if (method.toUpperCase() === 'POST') {
    return await postWithPagination(url, queryOptions)
  } else {
    return await getWithPagination(url, queryOptions)
  }
}

/**
 * 分页查询工具函数集合
 */
export const paginationUtils = {
  /**
   * 计算总页数
   * @param {number} total - 总数据量
   * @param {number} size - 每页数量
   * @returns {number} 总页数
   */
  calculatePages: (total, size) => Math.ceil(total / size),

  /**
   * 检查是否有下一页
   * @param {number} currentPage - 当前页码
   * @param {number} totalPages - 总页数
   * @returns {boolean} 是否有下一页
   */
  hasNextPage: (currentPage, totalPages) => currentPage < totalPages,

  /**
   * 检查是否有上一页
   * @param {number} currentPage - 当前页码
   * @returns {boolean} 是否有上一页
   */
  hasPrevPage: (currentPage) => currentPage > 1,

  /**
   * 获取页码范围
   * @param {number} currentPage - 当前页码
   * @param {number} totalPages - 总页数
   * @param {number} maxVisible - 最大可见页码数，默认为5
   * @returns {Array<number>} 页码范围数组
   */
  getPageRange: (currentPage, totalPages, maxVisible = 5) => {
    const pages = []
    const half = Math.floor(maxVisible / 2)
    
    let start = Math.max(1, currentPage - half)
    let end = Math.min(totalPages, start + maxVisible - 1)
    
    if (end - start + 1 < maxVisible) {
      start = Math.max(1, end - maxVisible + 1)
    }
    
    for (let i = start; i <= end; i++) {
      pages.push(i)
    }
    
    return pages
  },

  /**
   * 验证分页参数
   * @param {Object} params - 分页参数
   * @returns {Object} 验证后的参数
   */
  validateParams: (params) => {
    const { currentPage = 1, size = 10 } = params
    return {
      currentPage: Math.max(1, parseInt(currentPage) || 1),
      size: Math.max(1, Math.min(100, parseInt(size) || 10))
    }
  }
}

export default {
  PaginationQuery,
  createPaginationQuery,
  quickPaginationQuery,
  paginationUtils
} 